home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / mapping_tests.py < prev    next >
Text File  |  2005-10-18  |  22KB  |  673 lines
  1. # tests common to dict and UserDict
  2. import unittest
  3. import UserDict
  4.  
  5.  
  6. class BasicTestMappingProtocol(unittest.TestCase):
  7.     # This base class can be used to check that an object conforms to the
  8.     # mapping protocol
  9.  
  10.     # Functions that can be useful to override to adapt to dictionary
  11.     # semantics
  12.     type2test = None # which class is being tested (overwrite in subclasses)
  13.  
  14.     def _reference(self):
  15.         """Return a dictionary of values which are invariant by storage
  16.         in the object under test."""
  17.         return {1:2, "key1":"value1", "key2":(1,2,3)}
  18.     def _empty_mapping(self):
  19.         """Return an empty mapping object"""
  20.         return self.type2test()
  21.     def _full_mapping(self, data):
  22.         """Return a mapping object with the value contained in data
  23.         dictionary"""
  24.         x = self._empty_mapping()
  25.         for key, value in data.items():
  26.             x[key] = value
  27.         return x
  28.  
  29.     def __init__(self, *args, **kw):
  30.         unittest.TestCase.__init__(self, *args, **kw)
  31.         self.reference = self._reference().copy()
  32.  
  33.         # A (key, value) pair not in the mapping
  34.         key, value = self.reference.popitem()
  35.         self.other = {key:value}
  36.  
  37.         # A (key, value) pair in the mapping
  38.         key, value = self.reference.popitem()
  39.         self.inmapping = {key:value}
  40.         self.reference[key] = value
  41.  
  42.     def test_read(self):
  43.         # Test for read only operations on mapping
  44.         p = self._empty_mapping()
  45.         p1 = dict(p) #workaround for singleton objects
  46.         d = self._full_mapping(self.reference)
  47.         if d is p:
  48.             p = p1
  49.         #Indexing
  50.         for key, value in self.reference.items():
  51.             self.assertEqual(d[key], value)
  52.         knownkey = self.other.keys()[0]
  53.         self.failUnlessRaises(KeyError, lambda:d[knownkey])
  54.         #len
  55.         self.assertEqual(len(p), 0)
  56.         self.assertEqual(len(d), len(self.reference))
  57.         #has_key
  58.         for k in self.reference:
  59.             self.assert_(d.has_key(k))
  60.             self.assert_(k in d)
  61.         for k in self.other:
  62.             self.failIf(d.has_key(k))
  63.             self.failIf(k in d)
  64.         #cmp
  65.         self.assertEqual(cmp(p,p), 0)
  66.         self.assertEqual(cmp(d,d), 0)
  67.         self.assertEqual(cmp(p,d), -1)
  68.         self.assertEqual(cmp(d,p), 1)
  69.         #__non__zero__
  70.         if p: self.fail("Empty mapping must compare to False")
  71.         if not d: self.fail("Full mapping must compare to True")
  72.         # keys(), items(), iterkeys() ...
  73.         def check_iterandlist(iter, lst, ref):
  74.             self.assert_(hasattr(iter, 'next'))
  75.             self.assert_(hasattr(iter, '__iter__'))
  76.             x = list(iter)
  77.             self.assert_(set(x)==set(lst)==set(ref))
  78.         check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
  79.         check_iterandlist(iter(d), d.keys(), self.reference.keys())
  80.         check_iterandlist(d.itervalues(), d.values(), self.reference.values())
  81.         check_iterandlist(d.iteritems(), d.items(), self.reference.items())
  82.         #get
  83.         key, value = d.iteritems().next()
  84.         knownkey, knownvalue = self.other.iteritems().next()
  85.         self.assertEqual(d.get(key, knownvalue), value)
  86.         self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
  87.         self.failIf(knownkey in d)
  88.  
  89.     def test_write(self):
  90.         # Test for write operations on mapping
  91.         p = self._empty_mapping()
  92.         #Indexing
  93.         for key, value in self.reference.items():
  94.             p[key] = value
  95.             self.assertEqual(p[key], value)
  96.         for key in self.reference.keys():
  97.             del p[key]
  98.             self.failUnlessRaises(KeyError, lambda:p[key])
  99.         p = self._empty_mapping()
  100.         #update
  101.         p.update(self.reference)
  102.         self.assertEqual(dict(p), self.reference)
  103.         items = p.items()
  104.         p = self._empty_mapping()
  105.         p.update(items)
  106.         self.assertEqual(dict(p), self.reference)
  107.         d = self._full_mapping(self.reference)
  108.         #setdefault
  109.         key, value = d.iteritems().next()
  110.         knownkey, knownvalue = self.other.iteritems().next()
  111.         self.assertEqual(d.setdefault(key, knownvalue), value)
  112.         self.assertEqual(d[key], value)
  113.         self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
  114.         self.assertEqual(d[knownkey], knownvalue)
  115.         #pop
  116.         self.assertEqual(d.pop(knownkey), knownvalue)
  117.         self.failIf(knownkey in d)
  118.         self.assertRaises(KeyError, d.pop, knownkey)
  119.         default = 909
  120.         d[knownkey] = knownvalue
  121.         self.assertEqual(d.pop(knownkey, default), knownvalue)
  122.         self.failIf(knownkey in d)
  123.         self.assertEqual(d.pop(knownkey, default), default)
  124.         #popitem
  125.         key, value = d.popitem()
  126.         self.failIf(key in d)
  127.         self.assertEqual(value, self.reference[key])
  128.         p=self._empty_mapping()
  129.         self.assertRaises(KeyError, p.popitem)
  130.  
  131.     def test_constructor(self):
  132.         self.assertEqual(self._empty_mapping(), self._empty_mapping())
  133.  
  134.     def test_bool(self):
  135.         self.assert_(not self._empty_mapping())
  136.         self.assert_(self.reference)
  137.         self.assert_(bool(self._empty_mapping()) is False)
  138.         self.assert_(bool(self.reference) is True)
  139.  
  140.     def test_keys(self):
  141.         d = self._empty_mapping()
  142.         self.assertEqual(d.keys(), [])
  143.         d = self.reference
  144.         self.assert_(self.inmapping.keys()[0] in d.keys())
  145.         self.assert_(self.other.keys()[0] not in d.keys())
  146.         self.assertRaises(TypeError, d.keys, None)
  147.  
  148.     def test_values(self):
  149.         d = self._empty_mapping()
  150.         self.assertEqual(d.values(), [])
  151.  
  152.         self.assertRaises(TypeError, d.values, None)
  153.  
  154.     def test_items(self):
  155.         d = self._empty_mapping()
  156.         self.assertEqual(d.items(), [])
  157.  
  158.         self.assertRaises(TypeError, d.items, None)
  159.  
  160.     def test_len(self):
  161.         d = self._empty_mapping()
  162.         self.assertEqual(len(d), 0)
  163.  
  164.     def test_getitem(self):
  165.         d = self.reference
  166.         self.assertEqual(d[self.inmapping.keys()[0]], self.inmapping.values()[0])
  167.  
  168.         self.assertRaises(TypeError, d.__getitem__)
  169.  
  170.     def test_update(self):
  171.         # mapping argument
  172.         d = self._empty_mapping()
  173.         d.update(self.other)
  174.         self.assertEqual(d.items(), self.other.items())
  175.  
  176.         # No argument
  177.         d = self._empty_mapping()
  178.         d.update()
  179.         self.assertEqual(d, self._empty_mapping())
  180.  
  181.         # item sequence
  182.         d = self._empty_mapping()
  183.         d.update(self.other.items())
  184.         self.assertEqual(d.items(), self.other.items())
  185.  
  186.         # Iterator
  187.         d = self._empty_mapping()
  188.         d.update(self.other.iteritems())
  189.         self.assertEqual(d.items(), self.other.items())
  190.  
  191.         # FIXME: Doesn't work with UserDict
  192.         # self.assertRaises((TypeError, AttributeError), d.update, None)
  193.         self.assertRaises((TypeError, AttributeError), d.update, 42)
  194.  
  195.         outerself = self
  196.         class SimpleUserDict:
  197.             def __init__(self):
  198.                 self.d = outerself.reference
  199.             def keys(self):
  200.                 return self.d.keys()
  201.             def __getitem__(self, i):
  202.                 return self.d[i]
  203.         d.clear()
  204.         d.update(SimpleUserDict())
  205.         i1 = d.items()
  206.         i2 = self.reference.items()
  207.         i1.sort()
  208.         i2.sort()
  209.         self.assertEqual(i1, i2)
  210.  
  211.         class Exc(Exception): pass
  212.  
  213.         d = self._empty_mapping()
  214.         class FailingUserDict:
  215.             def keys(self):
  216.                 raise Exc
  217.         self.assertRaises(Exc, d.update, FailingUserDict())
  218.  
  219.         d.clear()
  220.  
  221.         class FailingUserDict:
  222.             def keys(self):
  223.                 class BogonIter:
  224.                     def __init__(self):
  225.                         self.i = 1
  226.                     def __iter__(self):
  227.                         return self
  228.                     def next(self):
  229.                         if self.i:
  230.                             self.i = 0
  231.                             return 'a'
  232.                         raise Exc
  233.                 return BogonIter()
  234.             def __getitem__(self, key):
  235.                 return key
  236.         self.assertRaises(Exc, d.update, FailingUserDict())
  237.  
  238.         class FailingUserDict:
  239.             def keys(self):
  240.                 class BogonIter:
  241.                     def __init__(self):
  242.                         self.i = ord('a')
  243.                     def __iter__(self):
  244.                         return self
  245.                     def next(self):
  246.                         if self.i <= ord('z'):
  247.                             rtn = chr(self.i)
  248.                             self.i += 1
  249.                             return rtn
  250.                         raise StopIteration
  251.                 return BogonIter()
  252.             def __getitem__(self, key):
  253.                 raise Exc
  254.         self.assertRaises(Exc, d.update, FailingUserDict())
  255.  
  256.         d = self._empty_mapping()
  257.         class badseq(object):
  258.             def __iter__(self):
  259.                 return self
  260.             def next(self):
  261.                 raise Exc()
  262.  
  263.         self.assertRaises(Exc, d.update, badseq())
  264.  
  265.         self.assertRaises(ValueError, d.update, [(1, 2, 3)])
  266.  
  267.     # no test_fromkeys or test_copy as both os.environ and selves don't support it
  268.  
  269.     def test_get(self):
  270.         d = self._empty_mapping()
  271.         self.assert_(d.get(self.other.keys()[0]) is None)
  272.         self.assertEqual(d.get(self.other.keys()[0], 3), 3)
  273.         d = self.reference
  274.         self.assert_(d.get(self.other.keys()[0]) is None)
  275.         self.assertEqual(d.get(self.other.keys()[0], 3), 3)
  276.         self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
  277.         self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0])
  278.         self.assertRaises(TypeError, d.get)
  279.         self.assertRaises(TypeError, d.get, None, None, None)
  280.  
  281.     def test_setdefault(self):
  282.         d = self._empty_mapping()
  283.         self.assertRaises(TypeError, d.setdefault)
  284.  
  285.     def test_popitem(self):
  286.         d = self._empty_mapping()
  287.         self.assertRaises(KeyError, d.popitem)
  288.         self.assertRaises(TypeError, d.popitem, 42)
  289.  
  290.     def test_pop(self):
  291.         d = self._empty_mapping()
  292.         k, v = self.inmapping.items()[0]
  293.         d[k] = v
  294.         self.assertRaises(KeyError, d.pop, self.other.keys()[0])
  295.  
  296.         self.assertEqual(d.pop(k), v)
  297.         self.assertEqual(len(d), 0)
  298.  
  299.         self.assertRaises(KeyError, d.pop, k)
  300.  
  301.  
  302. class TestMappingProtocol(BasicTestMappingProtocol):
  303.     def test_constructor(self):
  304.         BasicTestMappingProtocol.test_constructor(self)
  305.         self.assert_(self._empty_mapping() is not self._empty_mapping())
  306.         self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2})
  307.  
  308.     def test_bool(self):
  309.         BasicTestMappingProtocol.test_bool(self)
  310.         self.assert_(not self._empty_mapping())
  311.         self.assert_(self._full_mapping({"x": "y"}))
  312.         self.assert_(bool(self._empty_mapping()) is False)
  313.         self.assert_(bool(self._full_mapping({"x": "y"})) is True)
  314.  
  315.     def test_keys(self):
  316.         BasicTestMappingProtocol.test_keys(self)
  317.         d = self._empty_mapping()
  318.         self.assertEqual(d.keys(), [])
  319.         d = self._full_mapping({'a': 1, 'b': 2})
  320.         k = d.keys()
  321.         self.assert_('a' in k)
  322.         self.assert_('b' in k)
  323.         self.assert_('c' not in k)
  324.  
  325.     def test_values(self):
  326.         BasicTestMappingProtocol.test_values(self)
  327.         d = self._full_mapping({1:2})
  328.         self.assertEqual(d.values(), [2])
  329.  
  330.     def test_items(self):
  331.         BasicTestMappingProtocol.test_items(self)
  332.  
  333.         d = self._full_mapping({1:2})
  334.         self.assertEqual(d.items(), [(1, 2)])
  335.  
  336.     def test_has_key(self):
  337.         d = self._empty_mapping()
  338.         self.assert_(not d.has_key('a'))
  339.         d = self._full_mapping({'a': 1, 'b': 2})
  340.         k = d.keys()
  341.         k.sort()
  342.         self.assertEqual(k, ['a', 'b'])
  343.  
  344.         self.assertRaises(TypeError, d.has_key)
  345.  
  346.     def test_contains(self):
  347.         d = self._empty_mapping()
  348.         self.assert_(not ('a' in d))
  349.         self.assert_('a' not in d)
  350.         d = self._full_mapping({'a': 1, 'b': 2})
  351.         self.assert_('a' in d)
  352.         self.assert_('b' in d)
  353.         self.assert_('c' not in d)
  354.  
  355.         self.assertRaises(TypeError, d.__contains__)
  356.  
  357.     def test_len(self):
  358.         BasicTestMappingProtocol.test_len(self)
  359.         d = self._full_mapping({'a': 1, 'b': 2})
  360.         self.assertEqual(len(d), 2)
  361.  
  362.     def test_getitem(self):
  363.         BasicTestMappingProtocol.test_getitem(self)
  364.         d = self._full_mapping({'a': 1, 'b': 2})
  365.         self.assertEqual(d['a'], 1)
  366.         self.assertEqual(d['b'], 2)
  367.         d['c'] = 3
  368.         d['a'] = 4
  369.         self.assertEqual(d['c'], 3)
  370.         self.assertEqual(d['a'], 4)
  371.         del d['b']
  372.         self.assertEqual(d, {'a': 4, 'c': 3})
  373.  
  374.         self.assertRaises(TypeError, d.__getitem__)
  375.  
  376.     def test_clear(self):
  377.         d = self._full_mapping({1:1, 2:2, 3:3})
  378.         d.clear()
  379.         self.assertEqual(d, {})
  380.  
  381.         self.assertRaises(TypeError, d.clear, None)
  382.  
  383.     def test_update(self):
  384.         BasicTestMappingProtocol.test_update(self)
  385.         # mapping argument
  386.         d = self._empty_mapping()
  387.         d.update({1:100})
  388.         d.update({2:20})
  389.         d.update({1:1, 2:2, 3:3})
  390.         self.assertEqual(d, {1:1, 2:2, 3:3})
  391.  
  392.         # no argument
  393.         d.update()
  394.         self.assertEqual(d, {1:1, 2:2, 3:3})
  395.  
  396.         # keyword arguments
  397.         d = self._empty_mapping()
  398.         d.update(x=100)
  399.         d.update(y=20)
  400.         d.update(x=1, y=2, z=3)
  401.         self.assertEqual(d, {"x":1, "y":2, "z":3})
  402.  
  403.         # item sequence
  404.         d = self._empty_mapping()
  405.         d.update([("x", 100), ("y", 20)])
  406.         self.assertEqual(d, {"x":100, "y":20})
  407.  
  408.         # Both item sequence and keyword arguments
  409.         d = self._empty_mapping()
  410.         d.update([("x", 100), ("y", 20)], x=1, y=2)
  411.         self.assertEqual(d, {"x":1, "y":2})
  412.  
  413.         # iterator
  414.         d = self._full_mapping({1:3, 2:4})
  415.         d.update(self._full_mapping({1:2, 3:4, 5:6}).iteritems())
  416.         self.assertEqual(d, {1:2, 2:4, 3:4, 5:6})
  417.  
  418.         class SimpleUserDict:
  419.             def __init__(self):
  420.                 self.d = {1:1, 2:2, 3:3}
  421.             def keys(self):
  422.                 return self.d.keys()
  423.             def __getitem__(self, i):
  424.                 return self.d[i]
  425.         d.clear()
  426.         d.update(SimpleUserDict())
  427.         self.assertEqual(d, {1:1, 2:2, 3:3})
  428.  
  429.     def test_fromkeys(self):
  430.         self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
  431.         d = self._empty_mapping()
  432.         self.assert_(not(d.fromkeys('abc') is d))
  433.         self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
  434.         self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
  435.         self.assertEqual(d.fromkeys([]), {})
  436.         def g():
  437.             yield 1
  438.         self.assertEqual(d.fromkeys(g()), {1:None})
  439.         self.assertRaises(TypeError, {}.fromkeys, 3)
  440.         class dictlike(self.type2test): pass
  441.         self.assertEqual(dictlike.fromkeys('a'), {'a':None})
  442.         self.assertEqual(dictlike().fromkeys('a'), {'a':None})
  443.         self.assert_(dictlike.fromkeys('a').__class__ is dictlike)
  444.         self.assert_(dictlike().fromkeys('a').__class__ is dictlike)
  445.         # FIXME: the following won't work with UserDict, because it's an old style class
  446.         # self.assert_(type(dictlike.fromkeys('a')) is dictlike)
  447.         class mydict(self.type2test):
  448.             def __new__(cls):
  449.                 return UserDict.UserDict()
  450.         ud = mydict.fromkeys('ab')
  451.         self.assertEqual(ud, {'a':None, 'b':None})
  452.         # FIXME: the following won't work with UserDict, because it's an old style class
  453.         # self.assert_(isinstance(ud, UserDict.UserDict))
  454.         self.assertRaises(TypeError, dict.fromkeys)
  455.  
  456.         class Exc(Exception): pass
  457.  
  458.         class baddict1(self.type2test):
  459.             def __init__(self):
  460.                 raise Exc()
  461.  
  462.         self.assertRaises(Exc, baddict1.fromkeys, [1])
  463.  
  464.         class BadSeq(object):
  465.             def __iter__(self):
  466.                 return self
  467.             def next(self):
  468.                 raise Exc()
  469.  
  470.         self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
  471.  
  472.         class baddict2(self.type2test):
  473.             def __setitem__(self, key, value):
  474.                 raise Exc()
  475.  
  476.         self.assertRaises(Exc, baddict2.fromkeys, [1])
  477.  
  478.     def test_copy(self):
  479.         d = self._full_mapping({1:1, 2:2, 3:3})
  480.         self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
  481.         d = self._empty_mapping()
  482.         self.assertEqual(d.copy(), d)
  483.         self.assert_(isinstance(d.copy(), d.__class__))
  484.         self.assertRaises(TypeError, d.copy, None)
  485.  
  486.     def test_get(self):
  487.         BasicTestMappingProtocol.test_get(self)
  488.         d = self._empty_mapping()
  489.         self.assert_(d.get('c') is None)
  490.         self.assertEqual(d.get('c', 3), 3)
  491.         d = self._full_mapping({'a' : 1, 'b' : 2})
  492.         self.assert_(d.get('c') is None)
  493.         self.assertEqual(d.get('c', 3), 3)
  494.         self.assertEqual(d.get('a'), 1)
  495.         self.assertEqual(d.get('a', 3), 1)
  496.  
  497.     def test_setdefault(self):
  498.         BasicTestMappingProtocol.test_setdefault(self)
  499.         d = self._empty_mapping()
  500.         self.assert_(d.setdefault('key0') is None)
  501.         d.setdefault('key0', [])
  502.         self.assert_(d.setdefault('key0') is None)
  503.         d.setdefault('key', []).append(3)
  504.         self.assertEqual(d['key'][0], 3)
  505.         d.setdefault('key', []).append(4)
  506.         self.assertEqual(len(d['key']), 2)
  507.  
  508.     def test_popitem(self):
  509.         BasicTestMappingProtocol.test_popitem(self)
  510.         for copymode in -1, +1:
  511.             # -1: b has same structure as a
  512.             # +1: b is a.copy()
  513.             for log2size in range(12):
  514.                 size = 2**log2size
  515.                 a = self._empty_mapping()
  516.                 b = self._empty_mapping()
  517.                 for i in range(size):
  518.                     a[repr(i)] = i
  519.                     if copymode < 0:
  520.                         b[repr(i)] = i
  521.                 if copymode > 0:
  522.                     b = a.copy()
  523.                 for i in range(size):
  524.                     ka, va = ta = a.popitem()
  525.                     self.assertEqual(va, int(ka))
  526.                     kb, vb = tb = b.popitem()
  527.                     self.assertEqual(vb, int(kb))
  528.                     self.assert_(not(copymode < 0 and ta != tb))
  529.                 self.assert_(not a)
  530.                 self.assert_(not b)
  531.  
  532.     def test_pop(self):
  533.         BasicTestMappingProtocol.test_pop(self)
  534.  
  535.         # Tests for pop with specified key
  536.         d = self._empty_mapping()
  537.         k, v = 'abc', 'def'
  538.  
  539.         # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
  540.         # see SF bug #689659
  541.         x = 4503599627370496L
  542.         y = 4503599627370496
  543.         h = self._full_mapping({x: 'anything', y: 'something else'})
  544.         self.assertEqual(h[x], h[y])
  545.  
  546.         self.assertEqual(d.pop(k, v), v)
  547.         d[k] = v
  548.         self.assertEqual(d.pop(k, 1), v)
  549.  
  550.  
  551. class TestHashMappingProtocol(TestMappingProtocol):
  552.  
  553.     def test_getitem(self):
  554.         TestMappingProtocol.test_getitem(self)
  555.         class Exc(Exception): pass
  556.  
  557.         class BadEq(object):
  558.             def __eq__(self, other):
  559.                 raise Exc()
  560.  
  561.         d = self._empty_mapping()
  562.         d[BadEq()] = 42
  563.         self.assertRaises(KeyError, d.__getitem__, 23)
  564.  
  565.         class BadHash(object):
  566.             fail = False
  567.             def __hash__(self):
  568.                 if self.fail:
  569.                     raise Exc()
  570.                 else:
  571.                     return 42
  572.  
  573.         d = self._empty_mapping()
  574.         x = BadHash()
  575.         d[x] = 42
  576.         x.fail = True
  577.         self.assertRaises(Exc, d.__getitem__, x)
  578.  
  579.     def test_fromkeys(self):
  580.         TestMappingProtocol.test_fromkeys(self)
  581.         class mydict(self.type2test):
  582.             def __new__(cls):
  583.                 return UserDict.UserDict()
  584.         ud = mydict.fromkeys('ab')
  585.         self.assertEqual(ud, {'a':None, 'b':None})
  586.         self.assert_(isinstance(ud, UserDict.UserDict))
  587.  
  588.     def test_pop(self):
  589.         TestMappingProtocol.test_pop(self)
  590.  
  591.         class Exc(Exception): pass
  592.  
  593.         class BadHash(object):
  594.             fail = False
  595.             def __hash__(self):
  596.                 if self.fail:
  597.                     raise Exc()
  598.                 else:
  599.                     return 42
  600.  
  601.         d = self._empty_mapping()
  602.         x = BadHash()
  603.         d[x] = 42
  604.         x.fail = True
  605.         self.assertRaises(Exc, d.pop, x)
  606.  
  607.     def test_mutatingiteration(self):
  608.         d = self._empty_mapping()
  609.         d[1] = 1
  610.         try:
  611.             for i in d:
  612.                 d[i+1] = 1
  613.         except RuntimeError:
  614.             pass
  615.         else:
  616.             self.fail("changing dict size during iteration doesn't raise Error")
  617.  
  618.     def test_repr(self):
  619.         d = self._empty_mapping()
  620.         self.assertEqual(repr(d), '{}')
  621.         d[1] = 2
  622.         self.assertEqual(repr(d), '{1: 2}')
  623.         d = self._empty_mapping()
  624.         d[1] = d
  625.         self.assertEqual(repr(d), '{1: {...}}')
  626.  
  627.         class Exc(Exception): pass
  628.  
  629.         class BadRepr(object):
  630.             def __repr__(self):
  631.                 raise Exc()
  632.  
  633.         d = self._full_mapping({1: BadRepr()})
  634.         self.assertRaises(Exc, repr, d)
  635.  
  636.     def test_le(self):
  637.         self.assert_(not (self._empty_mapping() < self._empty_mapping()))
  638.         self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
  639.  
  640.         class Exc(Exception): pass
  641.  
  642.         class BadCmp(object):
  643.             def __eq__(self, other):
  644.                 raise Exc()
  645.  
  646.         d1 = self._full_mapping({BadCmp(): 1})
  647.         d2 = self._full_mapping({1: 1})
  648.         try:
  649.             d1 < d2
  650.         except Exc:
  651.             pass
  652.         else:
  653.             self.fail("< didn't raise Exc")
  654.  
  655.     def test_setdefault(self):
  656.         TestMappingProtocol.test_setdefault(self)
  657.  
  658.         class Exc(Exception): pass
  659.  
  660.         class BadHash(object):
  661.             fail = False
  662.             def __hash__(self):
  663.                 if self.fail:
  664.                     raise Exc()
  665.                 else:
  666.                     return 42
  667.  
  668.         d = self._empty_mapping()
  669.         x = BadHash()
  670.         d[x] = 42
  671.         x.fail = True
  672.         self.assertRaises(Exc, d.setdefault, x, [])
  673.